package com.cqq.common.core.util;

import java.lang.reflect.Array;
import java.util.ArrayList;
import java.util.Collection;
import java.util.LinkedList;
import java.util.List;

/**
 * <h3>List 构建类</h3>
 * 
 * <p>使用链式方式进行List的快速构建</p>
 * <pre class="code">ListBuilder.add(object1).and(object2).and(object3).build();</pre>
 * 
 * @author GUOQIANG
 * @version 1.0.0
 */
public class ListBuilder<T> {

	private List<T> list;

	private ListBuilder() {
		list = newArrayList();
	}

	/**
	 * <h3>添加一个对象</h3>
	 * 
	 * @param <T> 对象类型
	 * @param value 需要加入list的对象
	 * @return ListBuilder
	 */
	public static <T> ListBuilder<T> add(T value) {
		ListBuilder<T> listBuilder = new ListBuilder<T>();
		if (value != null) {
			listBuilder = listBuilder.and(value);
		}
		return listBuilder;
	}

	/**
	 * <h3>添加多个对象</h3>
	 * 
	 * @param <T> 对象类型
	 * @param values 需要加入list的对象
	 * @return ListBuilder
	 */
	public static <T> ListBuilder<T> addAll(T[] values) {
		ListBuilder<T> listBuilder = new ListBuilder<T>();
		if (values != null) {
			for (T value : values) {
				listBuilder = listBuilder.and(value);
			}
		}
		return listBuilder;
	}

	/**
	 * <h3>添加一个对象</h3>
	 * 
	 * @param value 需要加入list的对象
	 * @return ListBuilder
	 */
	public ListBuilder<T> and(T value) {
		if (value != null) {
			list.add(value);
		}
		return this;
	}

	/**
	 * <h3>删除一个对象</h3>
	 * 
	 * <p>所有相同对象都将被删除</p>
	 * 
	 * @param value 需要删除list的对象
	 * @return ListBuilder
	 */
	public ListBuilder<T> del(T value) {
		if (value != null) {
			list.removeAll(ListBuilder.add(value).build());
		}
		return this;
	}

	/**
	 * <h3>生成list对象</h3>
	 * 
	 * @return list
	 */
	public List<T> build() {
		return list;
	}

	/**
	 * <h3>生成array对象</h3>
	 * 
	 * <p>如果list中没有元素返回null</p>
	 * 
	 * @return list
	 */
	@SuppressWarnings("unchecked")
	public T[] buildArray() {
		T[] arr = null;
		for (T obj : list) {
			if (obj != null) {
				arr = (T[]) Array.newInstance(obj.getClass(), list.size());
				arr = list.toArray(arr);
				break;
			}
		}
		return arr;
	}

	public static <K> List<K> newArrayList() {
		return new ArrayList<K>();
	}

	public static <K> List<K> newArrayList(Collection<K> c) {
		return new ArrayList<K>(c);
	}

	public static <K> List<K> newArrayList(int size) {
		return new ArrayList<K>(size);
	}

	public static <K> LinkedList<K> newLinkedList() {
		return new LinkedList<K>();
	}

	public static <K> LinkedList<K> newLinkedList(Collection<K> c) {
		return new LinkedList<K>(c);
	}

	/**
	 * <h3>新建重组列表</h3>
	 * 
	 * <p>通过 Combiner 选择性重组集合</p>
	 * 
	 * @param c 需要重组的集合
	 * @param combiner 组合器
	 * @return list
	 */
	public static <K> List<K> newRecombinedList(Collection<K> c, Combiner<K> combiner) {
		List<K> list = newArrayList();
		for (K k : c) {
			if (combiner.isUseable(k)) {
				list.add(k);
			}
		}
		return list;
	}

	public static abstract class Combiner<K> {
		public abstract boolean isUseable(K k);
	}
}